Computers are used all over the world to perform a wide variety of tasks. Computers perform these tasks by executing software code. Software code is typically written by one or more software developers using some type of integrated development environment (IDE). In many cases, developers are given a set of design instructions, and, using a programming language, draft software code that will implement the functions described in the design specifications. Depending on the nature and scope of the design specifications (or any subsequent modifications thereto), code for the software program can often become lengthy and complex. It is well known that complex code is likely to contain software defects, also known as software bugs.
Software bugs can include a wide variety of problems from simple grammatical mistakes routinely detected by software compilers to semantic problems that are often very difficult to debug. Often, when a semantic problem prevents a software program from functioning correctly, the error is the result of improper inputs received by one software module from another software module or from internal processing within a software module. Most software programs include a plurality of software modules (e.g. functions, methods, classes, etc.), each configured to perform functions that often involve using other software modules. These modules work together to produce the desired result of the software program. Thus, if one module is producing faulty outputs, any module that receives those faulty outputs will produce invalid and/or improper results.
In order to perform the desired function, software modules communicate with each other in a manner specified by the program developer. The developer programs into each module certain requirements that are to be followed in order for the module to function correctly. Such requirements can include parameters that specify ranges of expected values that can be received and used as inputs. Alternatively, the requirements can specify range values for outputs that are to be used as inputs in other modules.
In cases where modules receive program values outside of the specified range, a violation typically occurs, causing the module to function incorrectly. Similarly, even if the module receives values within the expected range, if the module has an internal error, it may process the received values incorrectly and output values outside of those specified in the module requirements. Thus, the module designed to receive these improperly processed values will similarly result in a program violation, and so on.
Once a developer has determined that a semantic failure has occurred, the developer manually analyzes the software modules to determine where the error has occurred. Systematically, the developer narrows down the modules involved in the failed execution and determines which module(s) caused the failure. Next, the developer attempt to determine what in the module actually caused the failure. Then, the developer can determine how to fix the failure so that the failure does not occur on subsequent program executions. Such analysis, however, is often a time-consuming and lengthy process.